home *** CD-ROM | disk | FTP | other *** search
/ Complete Linux / Complete Linux.iso / docs / system / network / manageme / gobview_.z / gobview_ / gobview / gobview.cc < prev    next >
Encoding:
C/C++ Source or Header  |  1993-09-14  |  24.3 KB  |  888 lines
  1.  
  2. /******************************************************************************
  3. *
  4. * gobview - A post-processor for the dump-file generated by gobbler
  5. *           (net-sniffer)
  6. *
  7. * Author: Redproc (= Jacco in real life :)
  8. *
  9. * E-Mail: root@warns.et.tudelft.nl
  10. *         redproc@warns.et.tudelft.nl
  11. *
  12. * I used rdunix.c (distributed with the gobbler package, available through
  13. * anonymous ftp at ftp.et.tudelft.nl) written by Tirza van Rijn as a layer
  14. * to build my routines on.
  15. *
  16. * This program may be freely distributed and modified.
  17. *
  18. * Please send bug reports or anything you would like to mention to above
  19. * e-mail address
  20. *
  21. ******************************************************************************/
  22.  
  23. #include <stdio.h>
  24. #include <stdlib.h>
  25. #include <ctype.h>
  26. #include <string.h>
  27. #include <fcntl.h>
  28. #include <netdb.h>
  29.  
  30. #define    SIZE_ARRAY(x)    (sizeof(x)/sizeof(x[0]))
  31.  
  32.  
  33. typedef struct IP_Lookup
  34. {
  35.     IP_Lookup    *Next;
  36.     char        IP[16];            //    Max:   ???.???.???.??? + '\0'
  37.     char        Name[16];
  38. } IP_Lookup;
  39.  
  40.  
  41. IP_Lookup    *IP_Lookup_Cache;
  42.  
  43.  
  44. struct Name
  45. {
  46.     unsigned char    Hardware_Address[6];
  47.     char            Name[16];
  48. };
  49.  
  50. struct Name    Gateways[]=
  51. {
  52.     { {0xaa, 0x00, 0x04, 0x00, 0x1f, 0x74}, "dutrci1"}
  53. };
  54.  
  55. struct Protocol
  56. {
  57.     char    Name[8];
  58.     int        Offset, Length;    
  59.     char    ID[4];
  60.     char    Base[8];            //    Base of protocol:
  61.                                 //    e.g. IP is base of TCP.
  62.     char    PreComment[32], PostComment[32];
  63.     int        Data_PreOffset, Data_PostOffset;        //    e.g. [IP packet [TCP packet] end of IP packet]
  64.                                                     //                    /\         /\
  65.                                                     //                    ||           ||
  66.                                                     //          0         100        150              200
  67.                                                     //
  68.                                                     //    PreOffset = 100, PostOffset = 200 - 150 = 50
  69.  
  70.     void    (*Function) (char *Variable);
  71. };
  72.  
  73. void    LookUpIP (char *IP)
  74. {
  75.     char            Address[16] = "", Value[5], SystemName[32];
  76.     char            Command[256];
  77.  
  78.     FILE            *Process_Out;
  79.  
  80.     int                Index, Return_Read;
  81.  
  82.     unsigned char    Byte;
  83.  
  84.     IP_Lookup        *Cache_Window;
  85.  
  86.  
  87.  
  88.     sprintf(Value, "%u.\0", (unsigned char)*IP);
  89.     strcat(Address, Value);
  90.     sprintf(Value, "%u.\0", (unsigned char)*(IP + 1));
  91.     strcat(Address, Value);
  92.     sprintf(Value, "%u.\0", (unsigned char)*(IP + 2));
  93.     strcat(Address, Value);
  94.     sprintf(Value, "%u\0", (unsigned char)*(IP + 3));
  95.     strcat(Address, Value);
  96.  
  97.     Cache_Window = IP_Lookup_Cache;
  98.  
  99.     while (Cache_Window != NULL)
  100.     {
  101.         if (strcmp(Cache_Window->IP, Address) == 0)
  102.         {
  103.             /*    Cache hit!    */
  104.  
  105.             printf(" (%s)", (char *)Cache_Window->Name);
  106.  
  107.             return;
  108.         }
  109.  
  110.         Cache_Window = Cache_Window->Next;
  111.     }
  112.  
  113.  
  114.     sprintf(Command, "nslookup %s >/tmp/.process.out\0", (char *)Address);
  115.  
  116.  
  117.     system(Command);
  118.  
  119.  
  120.     Process_Out = fopen("/tmp/.process.out", "rb");
  121.  
  122.  
  123.     Return_Read = 0;
  124.  
  125.     while (Return_Read < 3)
  126.     {
  127.         fread(&Byte, 1, 1, Process_Out);
  128.  
  129.         if (Byte == '\n')
  130.         {
  131.             Return_Read++;
  132.         } 
  133.     }
  134.  
  135.     fread (Value, 1, 1, Process_Out);
  136.     fread (Value + 1, 1, 1, Process_Out);
  137.     fread (Value + 2, 1, 1, Process_Out);
  138.     fread (Value + 3, 1, 1, Process_Out);
  139.  
  140.     if (strncmp(Value, "Name", 4) == 0)
  141.     {
  142.         /*    Found it!    */
  143.  
  144.         fread(&Byte, 1, 1, Process_Out);                //    Byte = ':'
  145.  
  146.         do
  147.         {
  148.             fread(&Byte, 1, 1, Process_Out);
  149.         }
  150.         while (Byte == ' ');
  151.  
  152.  
  153.         Index = 0;
  154.  
  155.         while (Byte != 10)
  156.         {
  157.             SystemName[Index++] = Byte;
  158.  
  159.             if (fread(&Byte, 1, 1, Process_Out) != 1)
  160.             {
  161.                 break;
  162.             }
  163.         }
  164.  
  165.         SystemName[Index] = '\0';
  166.  
  167.         printf(" (%s)", (char *)SystemName);
  168.  
  169.  
  170.         /*    Now cache it. First create a new cache entry, and then    */
  171.         /*    prepend it.                                                */
  172.  
  173.         #ifdef    DEBUG
  174.             printf("Creating new cache entry...\n");
  175.         #endif
  176.  
  177.         Cache_Window = new IP_Lookup;
  178.  
  179.         Cache_Window->Next = IP_Lookup_Cache;
  180.  
  181.         strcpy (Cache_Window->IP, Address);
  182.  
  183.         #ifdef    DEBUG
  184.             printf("Cache_Window->IP = '%s'\n", Cache_Window->IP); 
  185.         #endif
  186.  
  187.         strcpy (Cache_Window->Name, SystemName);
  188.  
  189.         #ifdef    DEBUG
  190.             printf("Cache_Window->Name = '%s'\n", Cache_Window->Name); 
  191.         #endif
  192.  
  193.         IP_Lookup_Cache = Cache_Window;
  194.     }
  195.     else
  196.     {
  197.         /*    nslookup failed.    */
  198.  
  199.         printf( "(?)");
  200.     }
  201.  
  202.  
  203.     fclose (Process_Out);
  204. }
  205.  
  206. void Get_UDP_Service (char *Port)
  207. {
  208.     struct servent    *ServiceEntry;
  209.  
  210.  
  211.     ServiceEntry = getservbyport((int)(unsigned short *)*Port, "udp");
  212.  
  213.     printf("%s", ServiceEntry->s_name);
  214. }
  215.  
  216. void Get_TCP_Service (char *Port)
  217. {
  218.     struct servent    *ServiceEntry;
  219.  
  220.  
  221.     printf("Trying to find tcp service entry.\n");
  222.  
  223.  
  224.     ServiceEntry = getservbyport((int)(unsigned short *)*Port, "tcp");
  225.  
  226.     printf("%s", ServiceEntry->s_name);
  227. }
  228.  
  229. #define    HEX    0
  230. #define    DEC    1
  231. #define    IP    2
  232. #define    BIN    3
  233.  
  234. struct Protocol    Protocols[] =
  235. {
  236.     {"IP", -2*8, 2*8, {0x08, 0x00}, "...", "\nFound ", " protocol:\n", 20, 0, NULL},
  237.         {"...", 0, 4, {DEC}, "IP", "Version                 = ", "\n", 0, 0, NULL},
  238.         {"...", 4, 4, {DEC}, "IP", "Header length           = ", "\n", 0, 0, NULL},
  239.         {"...", 1*8, 1*8, {HEX}, "IP", "Sevice type             = ", "\n", 0, 0, NULL},
  240.         {"...", 2*8, 2*8, {DEC}, "IP", "Total length            = ", " bytes \n", 0, 0, NULL},
  241.         {"...", 4*8, 2*8, {HEX}, "IP", "ID                      = ", "\n", 0, 0, NULL},
  242.         {"...", 6*8, 3, {BIN}, "IP", "Fragmentation flags     = ", "\n", 0, 0, NULL},
  243.         {"...", 6*8, 12, {DEC}, "IP", "Fragmentation offset    = ", "\n", 0, 0, NULL},
  244.         {"...", 8*8, 1*8, {DEC}, "IP", "TTL                     = ", "\n", 0, 0, NULL},
  245.         {"...", 9*8, 1*8, {DEC}, "IP", "Protocol                = ", "\n", 0, 0, NULL},
  246.         {"...", 10*8, 2*8, {HEX}, "IP", "Checksum                = ", "\n", 0, 0, NULL},
  247.         {"...", 12*8, 4*8, {IP}, "IP", "Source IP address       = ", "\n", 0, 0, LookUpIP},
  248.         {"...", 16*8, 4*8, {IP}, "IP", "Destination IP address  = ", "\n", 0, 0, LookUpIP},
  249. //        {"...", , , {}, "IP", "", "\n", 0, 0, NULL},
  250.         {"ICMP", 9*8, 1*8, {1}, "IP", "\nFound ", " protocol:\n", 4, 0, NULL},
  251.             {"...", 0*8, 1*8, {DEC}, "ICMP", "Type     = ", "", 0, 0, NULL},
  252.                 {"???", 0*8, 1*8, {0}, "ICMP", " (Echo reply)", "\n", 4, 0, NULL},
  253.                 {"???", 0*8, 1*8, {3}, "ICMP", " (Destination unreachable)", "\n", 4, 0, NULL},
  254.                 {"???", 0*8, 1*8, {4}, "ICMP", " (Source quench)", "\n", 4, 0, NULL},
  255.                 {"???", 0*8, 1*8, {5}, "ICMP", " (Redirect)", "\n", 4, 0, NULL},
  256.                 {"???", 0*8, 1*8, {8}, "ICMP", " (Echo request)", "\n", 4, 0, NULL},
  257.                 {"???", 0*8, 1*8, {11}, "ICMP", " (Time exceeded)", "\n", 4, 0, NULL},
  258.                 {"???", 0*8, 1*8, {12}, "ICMP", " (Paramater problem)", "\n", 4, 0, NULL},
  259.                 {"???", 0*8, 1*8, {13}, "ICMP", " (Timestamp request)", "\n", 4, 0, NULL},
  260.                 {"???", 0*8, 1*8, {14}, "ICMP", " (Timestamp reply)", "\n", 4, 0, NULL},
  261.                 {"???", 0*8, 1*8, {15}, "ICMP", " (Info request (obsolete))", "\n", 4, 0, NULL},
  262.                 {"???", 0*8, 1*8, {16}, "ICMP", " (Info reply (obsolete))", "\n", 4, 0, NULL},
  263.                 {"???", 0*8, 1*8, {17}, "ICMP", " (Address mask request)", "\n", 4, 0, NULL},
  264.                 {"???", 0*8, 1*8, {18}, "ICMP", " (Address mask reply)", "\n", 4, 0, NULL},
  265.             {"...", 1*8, 1*8, {DEC}, "ICMP", "Code     = ", " ", 0, 0, NULL},
  266.                 {"???", 0*8, 1*8, {0}, "ICMP", "", "\n", 0, 0, NULL},                                        // Echo reply
  267.                 {"???", 0*8, 2*8, {3,0}, "ICMP", "(Network unreachable)", "", 0, 0, NULL},                    // Destination unreachable
  268.                     {"???", 0*8, 2*8, {3,1}, "ICMP", "(Host unreachable)", "", 0, 0, NULL},
  269.                     {"???", 0*8, 2*8, {3,2}, "ICMP", "(Protocol unreachable)", "", 0, 0, NULL},
  270.                     {"???", 0*8, 2*8, {3,3}, "ICMP", "(Port unreachable)", "", 0, 0, NULL},
  271.                     {"???", 0*8, 2*8, {3,4}, "ICMP", "(Fragmentation needed", " and DF set", 0, 0, NULL},
  272.                     {"???", 0*8, 2*8, {3,5}, "ICMP", "(Source route failed)", "", 0, 0, NULL},
  273.                     {"???", 0*8, 2*8, {3,6}, "ICMP", "(Destination network unknown)", "", 0, 0, NULL},
  274.                     {"???", 0*8, 2*8, {3,7}, "ICMP", "(Destination host unknown)", "", 0, 0, NULL},
  275.                     {"???", 0*8, 2*8, {3,8}, "ICMP", "(Source host isolated)", "", 0, 0, NULL},
  276.                     {"???", 0*8, 2*8, {3,9}, "ICMP", "(Communication destination", " network prohibited)", 0, 0, NULL},
  277.                     {"???", 0*8, 2*8, {3,10}, "ICMP", "(Communication destination", " host prohibited)", 0, 0, NULL},
  278.                     {"???", 0*8, 2*8, {3,11}, "ICMP", "(Network unreachable for ", "service)", 0, 0, NULL},
  279.                     {"???", 0*8, 2*8, {3,12}, "ICMP", "(Host unreachable for", " service)", 0, 0, NULL},
  280.                     {"???", 0, 8, {3}, "ICMP", "", "\n", 0, 0, NULL},            // Just a line feed
  281.                 {"???", 0*8, 1*8, {4}, "ICMP", "", "\n", 0, 0, NULL},                                            // Source quench
  282.                 {"???", 0*8, 2*8, {5,0}, "ICMP", "(Redirect for Net ", "(now obsolete))", 0, 0, NULL},            // Redirect
  283.                     {"???", 0*8, 2*8, {5,1}, "ICMP", "(Redirect for Host)", "", 0, 0, NULL},
  284.                     {"???", 0*8, 2*8, {5,2}, "ICMP", "(Redirect for service", " type and Net)", 0, 0, NULL},
  285.                     {"???", 0*8, 2*8, {5,3}, "ICMP", "(Redirect for service", " type and Host)", 0, 0, NULL},
  286.                     {"???", 0, 1, {5}, "ICMP", "", "\n", 0, 0, NULL},            // Just a line feed
  287.                 {"???", 0*8, 1*8, {8}, "ICMP", "", "\n", 0, 0, NULL},                                            // Echo request
  288.                 {"???", 0*8, 1*8, {11}, "ICMP", "", "\n", 0, 0, NULL},                                            // Time exceeded
  289.                 {"???", 0*8, 1*8, {12}, "ICMP", "", "\n", 0, 0, NULL},                                            // Paramater problem
  290.                 {"???", 0*8, 1*8, {13}, "ICMP", "", "\n", 0, 0, NULL},                                            // Timestamp request
  291.                 {"???", 0*8, 1*8, {14}, "ICMP", "", "\n", 0, 0, NULL},                                            // Timestamp reply
  292.                 {"???", 0*8, 1*8, {15}, "ICMP", "", "\n", 0, 0, NULL},                                            // Information request
  293.                 {"???", 0*8, 1*8, {16}, "ICMP", "", "\n", 0, 0, NULL},                                            // Information reply
  294.                 {"???", 0*8, 1*8, {17}, "ICMP", "", "\n", 0, 0, NULL},                                            // Address Mask Request
  295.                 {"???", 0*8, 1*8, {18}, "ICMP", "", "\n", 0, 0, NULL},                                            // Address Mask Reply
  296.             {"...", 2*8, 2*8, {HEX}, "ICMP", "Checksum = ", "\n", 0, 0, NULL},
  297.         {"GGP", 9*8, 1*8, {3}, "IP", "\nFound ", " protocol:\n", 0, 0, NULL},
  298.         {"ST", 9*8, 1*8, {5}, "IP", "\nFound ", " protocol:\n", 0, 0, NULL},
  299.         {"TCP", 9*8, 1*8, {6}, "IP", "\nFound ", " protocol:\n", 20, 0, NULL},
  300.             {"...", 0*8, 2*8, {DEC}, "TCP", "Source port        = ", "\n", 0, 0, NULL},
  301.             {"...", 2*8, 2*8, {DEC}, "TCP", "Destination port   = ", "\n", 0, 0, NULL},
  302.             {"...", 4*8, 4*8, {DEC}, "TCP", "Sequence number    = ", "\n", 0, 0, NULL},
  303.             {"...", 8*8, 4*8, {DEC}, "TCP", "Acknowledge number = ", "\n", 0, 0, NULL},
  304.             {"...", 12*8, 1*8, {DEC}, "TCP", "Data offset        = ", "\n", 0, 0, NULL},
  305.             {"...", 13*8, 1*8, {DEC}, "TCP", "Flags              = ", "\n", 0, 0, NULL},
  306.             {"...", 14*8, 2*8, {DEC}, "TCP", "Window             = ", "\n", 0, 0, NULL},
  307.             {"...", 16*8, 2*8, {HEX}, "TCP", "Checksum           = ", "\n", 0, 0, NULL},
  308.             {"...", 18*8, 2*8, {HEX}, "TCP", "Urgent pointer     = ", "\n", 0, 0, NULL},
  309.         {"UCL", 9*8, 1*8, {7}, "IP", "\nFound ", " protocol:\n", 0, 0, NULL},
  310.         {"EGP", 9*8, 1*8, {8}, "IP", "\nFound ", " protocol:\n", 0, 0, NULL},
  311.         {"IGP", 9*8, 1*8, {9}, "IP", "\nFound ", " protocol:\n", 0, 0, NULL},
  312.         {"UDP", 9*8, 1*8, {17}, "IP", "\nFound ", " protocol:\n", 8, 0, NULL},
  313.             {"...", 0*8, 2*8, {DEC}, "UDP", "Source port      = ", "\n", 0, 0, NULL},
  314.             {"...", 2*8, 2*8, {DEC}, "UDP", "Destination port = ", "\n", 0, 0, NULL},
  315.             {"...", 4*8, 2*8, {DEC}, "UDP", "Length           = ", "\n", 0, 0, NULL},
  316.             {"...", 6*8, 2*8, {HEX}, "UDP", "Checksum         = ", "\n", 0, 0, NULL},
  317.     {"ARP", -2*8, 2*8, {0x08, 0x06}, "...", "\nFound ", " frame:\n", 0, 0, NULL},
  318.     {"RARP", -2*8, 2*8, {0x80, 0x35}, "...", "\nFound ", " frame:\n", 0, 0, NULL},
  319. //    {"", , , {}, ""},
  320. };
  321.  
  322.  
  323. #define    NOTHING_FOUND    0
  324. #define    PROTOCOL_FOUND    1
  325. #define    VAR_FOUND        2
  326.  
  327.  
  328. #define REC_FRAME       0xF8        /* Marks start of a frame */
  329. #define BYTE            unsigned char
  330.  
  331. struct rec_hdr {
  332.     unsigned char type;
  333.     short len;
  334. };
  335.  
  336. /* Compare DP.H _DPBUF for the first 6 items */
  337. static struct frame {
  338.     short Dev;                      /* Logic dev# [0..DPMAXDEV-1]  */
  339.     unsigned long ClockMs;          /* Timestamp in micro seconds  */
  340.     unsigned short Status;          /* Status bits - internal use  */
  341.     unsigned short Size;            /* Packet length in bytes      */
  342.     BYTE *pBuf;                     /* Pointer to packet's content */
  343.     struct frame *pNext;            /* Pointer - internal use      */
  344.     BYTE DestAddr [6];              /* Packet destination address  */
  345.     BYTE SrcAddr [6];               /* Packet source address       */
  346.     BYTE PacketType [2];            /* Protocol type               */
  347.     BYTE Data[1600];                /* Packet data contents        */
  348. };
  349.  
  350.  
  351. int ReadByteFromFile (FILE *file, BYTE *b)
  352. {
  353.     return ((fread(b, 1, 1, file) == 1) ? 0 : EOF);
  354. }
  355.  
  356. int ReadIntFromFile (FILE *file, short *i)
  357. {
  358.     BYTE t1, t2;
  359.  
  360.     if (ReadByteFromFile(file, &t1) == EOF)
  361.         return (EOF);
  362.     if (ReadByteFromFile(file, &t2) == EOF)
  363.         return (EOF);
  364.     *i = (t2 << 8) | t1;
  365.     return (0);
  366. }
  367.  
  368. int ReadLongFromFile (FILE *file, long *l)
  369. {
  370.     BYTE t1, t2, t3, t4;
  371.  
  372.     if (ReadByteFromFile(file, &t1) == EOF)
  373.         return (EOF);
  374.     if (ReadByteFromFile(file, &t2) == EOF)
  375.         return (EOF);
  376.     if (ReadByteFromFile(file, &t3) == EOF)
  377.         return (EOF);
  378.     if (ReadByteFromFile(file, &t4) == EOF)
  379.         return (EOF);
  380.     *l = (t4 << 24) | (t3 << 16) | (t2 << 8) | t1;
  381.     return (0);
  382. }
  383.  
  384. void hexdump (BYTE *Data, unsigned short Length, int Indent)
  385. {
  386.     int i, j;
  387.     int c;
  388.     int    Space;
  389.  
  390.     #ifdef    DEBUG
  391.         printf("Hex dumping %u bytes at $%x\n", Length, Data);
  392.     #endif
  393.  
  394.  
  395.     for (Space = 0; Space < Indent; Space++)
  396.     {
  397.         printf(" ");
  398.     }
  399.  
  400.     for (i=0;i<(int)Length;i++)
  401.     {
  402.         printf ("%02x ", Data[i]);
  403.         if ((i & 15) == 15)
  404.         {
  405.             for (j=i-15;j<=i;j++)
  406.             {
  407.                 c = (int) Data[j];
  408.                 if (c >= ' ' && c <= '~')
  409.                     putchar (c);
  410.                 else
  411.                     putchar ('.');
  412.             }
  413.             printf("\n");
  414.  
  415.             for (Space = 0; Space < Indent; Space++)
  416.             {
  417.                 printf(" ");
  418.             }
  419.         }
  420.     }
  421.     for (i=(int)Length & 15;i<16;i++)
  422.         fputs("   ", stdout);
  423.     for (;j<(int)Length;j++)
  424.     {
  425.         c = (int) Data[j];
  426.         if (c >= ' ' && c <= '~')
  427.             putchar (c);
  428.         else
  429.             putchar ('.');
  430.     }
  431.     printf("\n");
  432. }
  433.  
  434. void HandlePacket(unsigned int, unsigned int, char *, unsigned int);
  435.  
  436. struct frame buf;
  437.  
  438.  
  439. int main(int argc, char *argv[])
  440. {
  441.     int t = 1;
  442.     FILE *dumpfile;
  443.     struct rec_hdr hdr;
  444.  
  445.     unsigned int    Indent, NameIndex, Index;
  446.  
  447.  
  448.     if (argc == 2)
  449.         dumpfile = fopen(argv[1], "r");
  450.     else
  451.         dumpfile = fopen("netcapt.dmp", "r");
  452.     if (dumpfile != NULL)
  453.     {
  454.  
  455.         /*    Try to read the config file 'process.conf' which contains the    */
  456.         /*    IP <-> Name table built so far. This is used as a cache for        */
  457.         /*    lookup using nslookup (which is slow). This way when a IP        */
  458.         /*    address is not in the cache, it's looked up once, and next        */
  459.         /*    time, it'll be a cache hit.                                        */
  460.         /*    Hmm, I tested a bit, and with the cache implemented the lookup    */
  461.         /*    is a LOT faster (surprise, surprise :). Building the cache        */
  462.         /*    everytime process is started is practically as fast as reading    */
  463.         /*    a cache file and writing it at the end, so I just build the        */
  464.         /*    cache dynamically: there's no file 'process.conf'.                */
  465.  
  466.  
  467.         IP_Lookup_Cache = NULL;
  468.  
  469.  
  470.         while ((ReadByteFromFile(dumpfile, &hdr.type) == 0) &&
  471.                (ReadIntFromFile(dumpfile, &hdr.len) == 0))
  472.         {
  473.             if (hdr.type == REC_FRAME)
  474.             {
  475.                 if ((ReadIntFromFile (dumpfile, &buf.Dev) == 0) &&
  476.                     (ReadLongFromFile (dumpfile, (long int *)&buf.ClockMs) == 0) &&
  477.                     (ReadIntFromFile (dumpfile, (short int *)&buf.Status) == 0) &&
  478.                     (ReadIntFromFile (dumpfile, (short int *)&buf.Size) == 0) &&
  479.                     (fread(&buf.pBuf, sizeof(buf.pBuf), 1, dumpfile) == 1) &&
  480.                     (fread(&buf.pNext, sizeof(buf.pNext), 1, dumpfile) == 1) &&
  481.                     (fread(&buf.DestAddr, sizeof(BYTE), 6, dumpfile) == 6) &&
  482.                     (fread(&buf.SrcAddr, sizeof(BYTE), 6, dumpfile) == 6) &&
  483.                     (fread(&buf.PacketType, sizeof(BYTE), 2, dumpfile) == 2) &&
  484.                     (fread(&buf.Data, sizeof(BYTE), (buf.Size-(6+6+2)), dumpfile) == (buf.Size-(6+6+2))))
  485.                 {
  486.                     printf("ETHERNET FRAME #%d\n", t++);
  487.                     printf("Frame length = %d\n", hdr.len);
  488. //                    printf("Logic device # = %d\n", buf.Dev);
  489.                     printf("Timestamp (in us): %d:%02d:%02d\n", (int)((buf.ClockMs / 1000000L) % 1000),
  490.                             (int)((buf.ClockMs / 1000L) % 1000), (int)(buf.ClockMs % 1000));
  491. //                    printf("Status %d\n", buf.Status);
  492.                     printf("Packet length (in bytes) = %d\n", buf.Size);
  493.  
  494.                     printf("Destination address: %02x:%02x:%02x:%02x:%02x:%02x",
  495.                             buf.DestAddr[0], buf.DestAddr[1],
  496.                             buf.DestAddr[2], buf.DestAddr[3],
  497.                             buf.DestAddr[4], buf.DestAddr[5]);
  498.         
  499.     
  500.             for (Index = 0; Index < SIZE_ARRAY(Gateways); Index++)
  501.             {
  502.                 #ifdef    DEBUG
  503.                     printf("Checking if hardware address is a gateway: ");
  504.                 #endif
  505.  
  506.                 for (NameIndex = 0; NameIndex < 6; NameIndex++)
  507.                 {
  508.                     #ifdef    DEBUG
  509.                         printf("%u / %u\n", Gateways[Index].Hardware_Address[NameIndex], buf.DestAddr[NameIndex]);
  510.                     #endif
  511.  
  512.                     if (Gateways[Index].Hardware_Address[NameIndex] != buf.DestAddr[NameIndex])
  513.                     {
  514.                         break;
  515.                     }
  516.                 }
  517.             
  518.                 if (NameIndex > 5)
  519.                 {
  520.                     printf(" (Gateway %s)", (char *)Gateways[Index].Name);
  521.  
  522.                     break;
  523.                 }
  524.             }
  525.  
  526.             if (NameIndex < 6)
  527.             {
  528.                 /*    Not a gateway.    */
  529.  
  530.                 LookUpIP((char *)(buf.Data + 16));
  531.             }
  532.  
  533.             printf("\n");
  534.  
  535.  
  536.                     printf("Source address: %02x:%02x:%02x:%02x:%02x:%02x",
  537.                             buf.SrcAddr[0], buf.SrcAddr[1],
  538.                             buf.SrcAddr[2], buf.SrcAddr[3],
  539.                             buf.SrcAddr[4], buf.SrcAddr[5]);
  540.     
  541.             for (Index = 0; Index < SIZE_ARRAY(Gateways); Index++)
  542.             {
  543.                 #ifdef    DEBUG
  544.                     printf("Checking if hardware address is a gateway: ");
  545.                 #endif
  546.  
  547.                 for (NameIndex = 0; NameIndex < 6; NameIndex++)
  548.                 {
  549.                     #ifdef    DEBUG
  550.                         printf("%u / %u\n", Gateways[Index].Hardware_Address[NameIndex], buf.SrcAddr[NameIndex]);
  551.                     #endif
  552.  
  553.                     if (Gateways[Index].Hardware_Address[NameIndex] != buf.SrcAddr[NameIndex])
  554.                     {
  555.                         break;
  556.                     }
  557.                 }
  558.             
  559.                 if (NameIndex > 5)
  560.                 {
  561.                     printf(" (Gateway %s)", (char *)Gateways[Index].Name);
  562.  
  563.                     break;
  564.                 }
  565.             }
  566.  
  567.             if (NameIndex < 6)
  568.             {
  569.                 /*    Not a gateway.    */
  570.  
  571.                 LookUpIP((char *)(buf.Data + 12));
  572.             }
  573.  
  574.             printf("\n");
  575.  
  576.                     printf("Protocol type: %02x%02x\n", buf.PacketType[0], buf.PacketType[1]);
  577.     
  578.             for (Index = 0; Index < SIZE_ARRAY(Protocols); Index++)
  579.             {
  580.                 if (strcmp(Protocols[Index].Base, "...") == 0)
  581.                 {
  582.                     if (strncmp(Protocols[Index].ID, (char *)(buf.Data + (Protocols[Index].Offset >> 3)),
  583.                                 (Protocols[Index].Length >> 3)) == 0)
  584.                     {
  585.                         #ifdef    DEBUG
  586.                             printf("Main protocol!\n");
  587.                         #endif
  588.  
  589.                         printf("%s%s%s",    Protocols[Index].PreComment, (char *)Protocols[Index].Name,
  590.                                             Protocols[Index].PostComment);
  591.  
  592.  
  593.                         Indent = 4;
  594.  
  595.                         HandlePacket(Index, Indent, (char *)buf.Data, buf.Size-(6+6+2));
  596.                     }
  597.                 }
  598.             }
  599.  
  600.  
  601.                    printf("\n\n\n");
  602.                 }
  603.             }
  604.             else
  605.             {
  606.                 fread(&buf, sizeof(BYTE), (hdr.len-3), dumpfile);
  607.             }
  608.         }
  609.     }
  610.     else
  611.     {
  612.         printf("Can't open dumpfile\n");
  613.     }
  614.  
  615.  
  616.     fclose(dumpfile);
  617.  
  618.     return (0);
  619. }
  620.  
  621.  
  622. void HandlePacket (unsigned int BaseIndex, unsigned int Indent, char *Buffer, unsigned int BufferLength)
  623. {
  624.     unsigned int    Index, Space, HandledProtocol = NOTHING_FOUND;
  625.  
  626.  
  627.     #ifdef    DEBUG
  628.         printf("\nHandlePacket called with buffer at $%x, length %u\n", Buffer, BufferLength);
  629.     #endif
  630.  
  631.  
  632.     for (Index = 0; Index < SIZE_ARRAY(Protocols); Index++)
  633.     {
  634.         if (strcmp(Protocols[BaseIndex].Name, Protocols[Index].Base) == 0)
  635.         {
  636.             /*    Check if it's a variable (Protocol.Name == "...") or a protocol.    */
  637.  
  638.             if (strcmp(Protocols[Index].Name, "...") == 0)
  639.             {
  640.                 /*    It's a var.    */
  641.  
  642.                 HandledProtocol |= VAR_FOUND;
  643.  
  644.                 #ifdef    DEBUG
  645.                     printf("Var found\n");
  646.                 #endif
  647.  
  648.                 for (Space = 0; Space < Indent; Space++)
  649.                 {
  650.                     printf(" ");
  651.                 }
  652.  
  653.                 printf("%s", Protocols[Index].PreComment);
  654.  
  655.                 switch (Protocols[Index].ID[0])
  656.                 {
  657.                     case DEC:
  658.                             switch (Protocols[Index].Length)
  659.                             {
  660.                                 case    1*8:
  661.                                             printf("%u", (unsigned char)*(Buffer + (Protocols[Index].Offset >> 3)));
  662.  
  663.                                             break;
  664.                                 case    2*8:
  665.                                             printf("%u", ( (unsigned char)*(Buffer + (Protocols[Index].Offset >> 3))*256 +
  666.                                                             (unsigned char)*(Buffer + (Protocols[Index].Offset >> 3) + 1) ));
  667.  
  668.                                             break;
  669.  
  670.                                 default:
  671.                                         unsigned long int    Dec = 0;
  672.                                         int                    Length, Offset;
  673.  
  674.                                         Length = Protocols[Index].Length;
  675.                                         Offset = Protocols[Index].Offset;
  676.  
  677.                                         #ifdef    DEBUG
  678.                                             printf("data = 0x%x\n", (unsigned char)Buffer[Offset >> 3]);
  679.                                         #endif
  680.  
  681.                                         while (Length > 0)
  682.                                         {
  683.                                             #ifdef    DEBUG
  684.                                                 printf("Data at offset = %u, length = %u\n", Offset, Length);
  685.                                             #endif
  686.  
  687.  
  688.                                             if ( ( ((unsigned char)Buffer[Offset >> 3]) & (1 << (7 - (Offset & 0x07))) ) != 0)
  689.                                             {
  690.                                                 #ifdef    DEBUG
  691.                                                     printf(" 1");
  692.                                                 #endif
  693.  
  694.                                                 Dec += 1 << (Length - 1);
  695.                                             }
  696.                                             #ifdef    DEBUG
  697.                                                 else
  698.                                                 {
  699.                                                     printf(" 0");
  700.                                                 }
  701.                                             #endif
  702.  
  703.  
  704.                                             Offset++;
  705.                                             Length--;
  706.                                         }
  707.  
  708.                                         printf("%u", Dec);
  709.  
  710.                                         break;
  711.                             }
  712.  
  713.                             break;
  714.                     case IP:
  715.                             printf("%u.", (unsigned char)*(Buffer + (Protocols[Index].Offset >> 3)));
  716.                             printf("%u.", (unsigned char)*(Buffer + (Protocols[Index].Offset >> 3) + 1));
  717.                             printf("%u.", (unsigned char)*(Buffer + (Protocols[Index].Offset >> 3) + 2));
  718.                             printf("%u", (unsigned char)*(Buffer + (Protocols[Index].Offset >> 3) + 3));
  719.  
  720.                             break;
  721.  
  722.                     case HEX:
  723. /*                            printf("0x");
  724.  
  725.                             for (Space = 0; Space < (Protocols[Index].Length >> 3); Space++)
  726.                             {
  727.                                 printf("%02x", (unsigned char)Buffer[(Protocols[Index].Offset >> 3) + Space]);
  728.                             }
  729.  
  730.                             break;
  731. */
  732.                             unsigned long int    Hex = 0;
  733.                             int                    Length, Offset;
  734.  
  735.                             Length = Protocols[Index].Length;
  736.                             Offset = Protocols[Index].Offset;
  737.  
  738.  
  739.                             while (Length > 0)
  740.                             {
  741.  
  742.                                 if ( ( ((unsigned char)Buffer[Offset >> 3]) & (1 << (7 - (Offset & 0x07))) ) != 0)
  743.                                 {
  744.  
  745.                                     Hex += 1 << (Length - 1);
  746.                                 }
  747.  
  748.                                 Offset++;
  749.                                 Length--;
  750.                             }
  751.  
  752.                             printf("0x%x", Hex);
  753.  
  754.                             break;
  755.  
  756.                     case BIN:
  757.  
  758.                             Length = Protocols[Index].Length;
  759.                             Offset = Protocols[Index].Offset;
  760.  
  761.  
  762.                             printf("%%");
  763.  
  764.                             while (Length > 0)
  765.                             {
  766.  
  767.                                 if ( ( ((unsigned char)Buffer[Offset >> 3]) & (1 << (7 - (Offset & 0x07))) ) != 0)
  768.                                 {
  769.  
  770.                                     printf("1");
  771.                                 }
  772.                                 else
  773.                                 {
  774.                                     printf("0");
  775.                                 }
  776.  
  777.                                 Offset++;
  778.                                 Length--;
  779.                             }
  780.  
  781.                             break;
  782.                 }
  783.  
  784.  
  785.                 if (Protocols[Index].Function != NULL)
  786.                 {
  787.                     Protocols[Index].Function(Buffer + (Protocols[Index].Offset >> 3));
  788.                 }
  789.  
  790.                 printf("%s", Protocols[Index].PostComment);
  791.             }
  792.             else
  793.             {
  794.                 /*    It's a protocol.    */
  795.  
  796.                 #ifdef    DEBUG
  797.                     printf("Testing protocol %s...", Protocols[Index].Name);
  798.                 #endif
  799.  
  800.                 if (strncmp(Protocols[Index].ID,
  801.                             (char *)(Buffer + ( Protocols[Index].Offset >> 3)),
  802.                             (Protocols[Index].Length >> 3)) == 0)
  803.                 {
  804.                     if (strncmp(Protocols[Index].Name, "???", 3) != 0)
  805.                     {
  806.                         HandledProtocol |= PROTOCOL_FOUND;
  807.  
  808.                         #ifdef    DEBUG
  809.                             printf("and found it!\n");
  810.                         #endif
  811.  
  812.                         for (Space = 0; Space < Indent; Space++)
  813.                         {
  814.                             printf(" ");
  815.                         }
  816.  
  817.  
  818.                         printf("%s%s%s",    Protocols[Index].PreComment, (char *)Protocols[Index].Name,
  819.                                             Protocols[Index].PostComment);
  820.  
  821.  
  822.                         HandlePacket(    Index, Indent+4, Buffer + Protocols[BaseIndex].Data_PreOffset,
  823.                                             BufferLength - Protocols[BaseIndex].Data_PostOffset - 
  824.                                             Protocols[BaseIndex].Data_PreOffset);
  825.                     }
  826.                     else
  827.                     {
  828.                         /*    It's a '???' 'protocol'    */
  829.  
  830.                         HandledProtocol |= VAR_FOUND;
  831.  
  832.                         printf("%s%s",    Protocols[Index].PreComment, Protocols[Index].PostComment);
  833.  
  834.                     }
  835.                 }
  836.             }
  837.         }
  838.     }
  839.  
  840.  
  841.     #ifdef    DEBUG
  842.         printf("HandledProtocol = %u\n", HandledProtocol);
  843.     #endif
  844.  
  845.     if ((HandledProtocol & PROTOCOL_FOUND) != PROTOCOL_FOUND)
  846.     {
  847.         /*    Print data.    */
  848.  
  849.         #ifdef    DEBUG
  850.             printf("Printing data, no sub-protocol found:");
  851.         #endif
  852.  
  853.         for (Space = 0; Space < Indent; Space++)
  854.         {
  855.             printf(" ");
  856.         }
  857.  
  858.         printf("Encapsulated data:\n");
  859.  
  860.         hexdump((BYTE *)Buffer + Protocols[BaseIndex].Data_PreOffset,
  861.                 BufferLength - Protocols[BaseIndex].Data_PostOffset -
  862.                 Protocols[BaseIndex].Data_PreOffset, Indent + 1 + 4);
  863.     }
  864.  
  865.     /*    Print data.    */
  866.  
  867.     if (Protocols[Index].Data_PostOffset > 0)
  868.     {
  869.         #ifdef    DEBUG
  870.             printf("Printing data:");
  871.         #endif
  872.  
  873.         for (Space = 0; Space < Indent; Space++)
  874.         {
  875.             printf(" ");
  876.         }
  877.  
  878.         printf("Data: \n");
  879.  
  880.         hexdump((BYTE *)Buffer + BufferLength - Protocols[Index].Data_PostOffset,
  881.                 Protocols[Index].Data_PostOffset, Indent + 1);
  882.     }
  883.  
  884.     #ifdef    DEBUG
  885.         printf("RETURN\n");
  886.     #endif
  887. }
  888.